home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / vsrc.tar / voyager7_src / objects.c < prev    next >
C/C++ Source or Header  |  1991-02-27  |  31KB  |  1,662 lines
  1. /*
  2. // Abstract:
  3. //    OBJECTS---HP 48SX Objects
  4. //
  5. //    The HP 48SX Objects module contains routines to format and
  6. //    display objects contained in the HP 48SX.
  7. //
  8. // Author:
  9. //    Derek S. Nickel
  10. //
  11. // Creation date:
  12. //    25 October 1990
  13. //
  14. // History:
  15. // V01-001    Derek S. Nickel        25-OCT-1990
  16. //    Original.
  17. //
  18. */
  19.  
  20. #include <ctype.h>
  21. #include <io.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24.  
  25. #include "memory.h"
  26. #include "modes.h"
  27. #include "objects.h"
  28. #include "pager.h"
  29. #include "index.h"
  30. #include "instruct.h"
  31.  
  32. static int display_object(bin5_t *origWP, bin5_t *ta);
  33. static char *get_prolog_description(bin5_t prolog, char *buf);
  34. static bin5_t follow_refernece(bin5_t adr);
  35.  
  36. /***********************************************************************
  37.     Object Prologs and Other Addresses
  38. ***********************************************************************/
  39.  
  40. bin5_t
  41.     prolog_system_binary = 0x02911,
  42.     prolog_real_number = 0x02933,
  43.     prolog_long_real = 0x02955,
  44.     prolog_complex_number = 0x02977,
  45.     prolog_long_complex = 0x0299D,
  46.     prolog_character = 0x029BF,
  47.     prolog_array = 0x029E8,
  48.     prolog_linked_array = 0x02A0A,
  49.     prolog_string = 0x02A2C,
  50.     prolog_binary_integer = 0x02A4E,
  51.     prolog_list = 0x02A74,
  52.     prolog_directory = 0x02A96,
  53.     prolog_algebraic = 0x02AB8,
  54.     prolog_unit = 0x02ADA,
  55.     prolog_tagged = 0x02AFC,
  56.     prolog_graphic = 0x02B1E,
  57.     prolog_library = 0x02B40,
  58.     prolog_backup = 0x02B62,
  59.     prolog_library_data = 0x02B88,
  60.     prolog_program = 0x02D9D,
  61.     prolog_code = 0x02DCC,
  62.     prolog_global_name = 0x02E48,
  63.     prolog_local_name = 0x02E6D,
  64.     prolog_xlib_name = 0x02E92,
  65.     end_marker = 0x0312B;
  66.  
  67. /***********************************************************************
  68.     get_prolog_description
  69. ***********************************************************************/
  70.  
  71. static char *get_prolog_description(bin5_t prolog, char *buf)
  72. {
  73.     static char *prolog_names[] = {
  74.         "External",
  75.         "System Binary",
  76.         "Real Number",
  77.         "Long Real",
  78.         "Complex Number",
  79.         "Long Complex",
  80.         "Character",
  81.         "Array",
  82.         "Linked Array",
  83.         "String",
  84.         "Binary Integer",
  85.         "List",
  86.         "Directory",
  87.         "Algebraic",
  88.         "Unit",
  89.         "Tagged",
  90.         "Graphic",
  91.         "Library",
  92.         "Backup",
  93.         "Library Data",
  94.         "Program",
  95.         "Code",
  96.         "Global Name",
  97.         "Local Name",
  98.         "XLIB Name" };
  99.  
  100.     int idx = 0;
  101.  
  102.     if (prolog == prolog_system_binary) {
  103.         idx = 1;
  104.     } else if (prolog == prolog_real_number) {
  105.         idx = 2;
  106.     } else if (prolog == prolog_long_real) {
  107.         idx = 3;
  108.     } else if (prolog == prolog_complex_number) {
  109.         idx = 4;
  110.     } else if (prolog == prolog_long_complex) {
  111.         idx = 5;
  112.     } else if (prolog == prolog_character) {
  113.         idx = 6;
  114.     } else if (prolog == prolog_array) {
  115.         idx = 7;
  116.     } else if (prolog == prolog_linked_array) {
  117.         idx = 8;
  118.     } else if (prolog == prolog_string) {
  119.         idx = 9;
  120.     } else if (prolog == prolog_binary_integer) {
  121.         idx = 10;
  122.     } else if (prolog == prolog_list) {
  123.         idx = 11;
  124.     } else if (prolog == prolog_directory) {
  125.         idx = 12;
  126.     } else if (prolog == prolog_algebraic) {
  127.         idx = 13;
  128.     } else if (prolog == prolog_unit) {
  129.         idx = 14;
  130.     } else if (prolog == prolog_tagged) {
  131.         idx = 15;
  132.     } else if (prolog == prolog_graphic) {
  133.         idx = 16;
  134.     } else if (prolog == prolog_library) {
  135.         idx = 17;
  136.     } else if (prolog == prolog_backup) {
  137.         idx = 18;
  138.     } else if (prolog == prolog_library_data) {
  139.         idx = 19;
  140.     } else if (prolog == prolog_program) {
  141.         idx = 20;
  142.     } else if (prolog == prolog_code) {
  143.         idx = 21;
  144.     } else if (prolog == prolog_global_name) {
  145.         idx = 22;
  146.     } else if (prolog == prolog_local_name) {
  147.         idx = 23;
  148.     } else if (prolog == prolog_xlib_name) {
  149.         idx = 24;
  150.     }
  151.  
  152.     return strcpy(buf,prolog_names[idx]);
  153. }
  154.  
  155. /***********************************************************************
  156.     hex_to_text
  157. ***********************************************************************/
  158.  
  159. static char *hex_to_text(char *buf, char *display)
  160. {
  161.     int i;
  162.     char ch, nib0, nib1;
  163.     char *p;
  164.     char *q;
  165.  
  166.     p = buf;
  167.     q = display;
  168.  
  169.     while (*p) {
  170.         nib0 = *p++;
  171.         nib1 = *p++;
  172.         ch = hexval(nib0) + (hexval(nib1) << 4);
  173.  
  174.         if (isprint(ch))
  175.             *q++ = ch;
  176.         else
  177.             *q++ = '.';
  178.     }
  179.  
  180.     *q++ = '\0';
  181.  
  182.     return display;
  183. }
  184.  
  185. /***********************************************************************
  186.     format_real_number
  187. ***********************************************************************/
  188.  
  189. static void format_real_number(char *buf, char *display)
  190. {
  191.     char buf2[17];
  192.     char *p;
  193.     char *q;
  194.     long digits;
  195.     long i;
  196.     long exp;
  197.  
  198.     strcpy(buf2,buf);
  199.     strrev(buf2);
  200.  
  201.     p = &buf2[12];
  202.     q = &buf2[1];
  203.  
  204.     while (p > q && *p == '0')
  205.         p--;
  206.  
  207.     digits = p - q + 1;
  208.  
  209.     exp = atol(&buf2[13]);
  210.     if (exp > 499)
  211.         exp = exp - 1000;
  212.  
  213.     p = buf2;
  214.     q = display;
  215.  
  216.     if (*p++ != '0') *q++ = '-';
  217.  
  218.     if (exp >= 0 && exp <= 11) {
  219.  
  220.         for (i = 0; i < digits-1; i++) {
  221.             *q++ = *p++;
  222.             if (i == exp) *q++ = '.';
  223.         }
  224.  
  225.         *q++ = *p++;
  226.  
  227.         for (i = digits; i <= exp; i++) {
  228.             *q++ = '0';
  229.         }
  230.  
  231.         *q = '\0';
  232.  
  233.     } else if (exp >= -12 && exp <= -1) {
  234.  
  235.         *q++ = '.';
  236.  
  237.         for (i = 1; i < -exp; i++) {
  238.             *q++ = '0';
  239.         }
  240.  
  241.         for (i = 0; i < digits; i++) {
  242.             *q++ = *p++;
  243.         }
  244.  
  245.         *q = '\0';
  246.  
  247.     } else {
  248.         *q++ = *p++;
  249.         *q++ = '.';
  250.  
  251.         for (i = 1; i < digits; i++)
  252.             *q++ = *p++;
  253.  
  254.         *q++ = 'E';
  255.         *q = '\0';
  256.  
  257.         ltoa(exp,q,10);
  258.     }
  259. }
  260.  
  261. /***********************************************************************
  262.     format_long_real
  263. ***********************************************************************/
  264.  
  265. static void format_long_real(char *buf, char *display)
  266. {
  267.     char buf2[22];
  268.     char *p;
  269.     char *q;
  270.     long digits;
  271.     long i;
  272.     long exp;
  273.  
  274.     strcpy(buf2,buf);
  275.     strrev(buf2);
  276.  
  277.     p = &buf2[15];
  278.     q = &buf2[1];
  279.  
  280.     while (p > q && *p == '0')
  281.         p--;
  282.  
  283.     digits = p - q + 1;
  284.  
  285.     exp = atol(&buf2[16]);
  286.     if (exp > 49999)
  287.         exp = exp - 100000;
  288.  
  289.     p = buf2;
  290.     q = display;
  291.  
  292.     if (*p++ != '0') *q++ = '-';
  293.  
  294.     if (exp >= 0 && exp <= 14) {
  295.  
  296.         for (i = 0; i < digits-1; i++) {
  297.             *q++ = *p++;
  298.             if (i == exp) *q++ = '.';
  299.         }
  300.  
  301.         *q++ = *p++;
  302.  
  303.         for (i = digits; i <= exp; i++) {
  304.             *q++ = '0';
  305.         }
  306.  
  307.         *q = '\0';
  308.  
  309.     } else if (exp >= -15 && exp <= -1) {
  310.  
  311.         *q++ = '.';
  312.  
  313.         for (i = 1; i < -exp; i++) {
  314.             *q++ = '0';
  315.         }
  316.  
  317.         for (i = 0; i < digits; i++) {
  318.             *q++ = *p++;
  319.         }
  320.  
  321.         *q = '\0';
  322.  
  323.     } else {
  324.         *q++ = *p++;
  325.         *q++ = '.';
  326.  
  327.         for (i = 1; i < digits; i++)
  328.             *q++ = *p++;
  329.  
  330.         *q++ = 'E';
  331.         *q = '\0';
  332.  
  333.         ltoa(exp,q,10);
  334.     }
  335. }
  336.  
  337. /***********************************************************************
  338.     format_character
  339. ***********************************************************************/
  340.  
  341. static void format_character(char *buf,char *display)
  342. {
  343.     char buf2[3];
  344.     char ch;
  345.  
  346.     strcpy(buf2,buf);
  347.     strrev(buf2);
  348.  
  349.     ch = (hexval(buf2[0]) << 4) + hexval(buf2[1]);
  350.     if (!isprint(ch)) ch = '.';
  351.  
  352.     sprintf(display,"'%c' 0x%s", ch, buf2);
  353. }
  354.  
  355. /***********************************************************************
  356.     get_ascic
  357. ***********************************************************************/
  358.  
  359. static void get_ascic(char *display)
  360. {
  361.     char buf2[3];
  362.     char buf3[65];
  363.     bin5_t size;
  364.  
  365.     GetNNibbles(buf2,2);
  366.     strrev(buf2);
  367.     size = 2*str2adr(buf2,0);
  368.  
  369.     if (size <= 64) {
  370.         /*
  371.         // Can be displayed on one line.
  372.         */
  373.  
  374.         GetNNibbles(buf3,size);
  375.         hex_to_text(buf3,display);
  376.  
  377.     } else {
  378.         /*
  379.         // Truncate the name (and fetch remaining data).
  380.         */
  381.  
  382.         GetNNibbles(buf3,58);
  383.         size -= 58;
  384.         hex_to_text(buf3,display);
  385.         strcat(display,"...");
  386.  
  387.         while (size >= 64) {
  388.             GetNNibbles(buf3,64);
  389.             size -= 64;
  390.         }
  391.         GetNNibbles(buf3,size);
  392.     }
  393. }
  394.  
  395. /***********************************************************************
  396.     get_ascix
  397. ***********************************************************************/
  398.  
  399. static void get_ascix(char *display)
  400. {
  401.     char buf2[3];
  402.     char buf3[65];
  403.     bin5_t size;
  404.  
  405.     GetNNibbles(buf2,2);
  406.     strrev(buf2);
  407.     size = 2*str2adr(buf2,0);
  408.  
  409.     if (size == 0) {
  410.         /*
  411.         // Zero length name, no trailing size field.
  412.         */
  413.  
  414.         *display = '\0';
  415.  
  416.     } else if (size <= 64) {
  417.         /*
  418.         // Can be displayed on one line.
  419.         */
  420.  
  421.         GetNNibbles(buf3,size);
  422.         hex_to_text(buf3,display);
  423.         GetNNibbles(buf2,2);
  424.  
  425.     } else {
  426.         /*
  427.         // Truncate the name and fetch remaining data.
  428.         */
  429.  
  430.         GetNNibbles(buf3,58);
  431.         size -= 58;
  432.         hex_to_text(buf3,display);
  433.         strcat(display,"...");
  434.  
  435.         while (size >= 64) {
  436.             GetNNibbles(buf3,64);
  437.             size -= 64;
  438.         }
  439.         GetNNibbles(buf3,size);
  440.         GetNNibbles(buf2,2);
  441.     }
  442. }
  443.  
  444. /***********************************************************************
  445. ***********************************************************************/
  446.  
  447. static bin5_t follow_reference(bin5_t adr)
  448. {
  449.     bin5_t tmp;
  450.  
  451.     /*
  452.     // Get the prolog.
  453.     */
  454.  
  455.     SetWorkPtr(adr);
  456.     tmp = get_bin5();
  457.  
  458.     /*
  459.     // If this is a System Binary...
  460.     */
  461.  
  462.     if (tmp == prolog_system_binary) {
  463.         /*
  464.         // ...display the reference...
  465.         */
  466.  
  467.         bin5_t data;
  468.         char *acom;
  469.  
  470.         acom = get_address_comment(adr);
  471.         if (*acom) {
  472.             pager(0);
  473.             printf("%05lX: ; *** %s ***\n", adr, acom);
  474.         }
  475.  
  476.         data = get_bin5();
  477.  
  478.         pager(0);
  479.         acom = get_address_comment(data);
  480.         if (*acom)
  481.             printf("%05lX: [...] ! <%lXh>\t; %s\n",
  482.                 adr, data, acom );
  483.         else
  484.             printf("%05lX: [...] ! <%lXh>\n", adr, data );
  485.  
  486.         /*
  487.         // ...and follow reference.
  488.         */
  489.  
  490.         adr = data;
  491.     }
  492.  
  493.     return adr;
  494. }
  495.  
  496. /***********************************************************************
  497.     display_hash_table
  498. ***********************************************************************/
  499.  
  500. void display_hash_table(bin5_t adr, bin5_t lib_no)
  501. {
  502.     bin5_t ht_size;
  503.     bin5_t nt_size;
  504.     bin5_t ht_end;
  505.     bin5_t nt_end;
  506.     bin5_t tmp;
  507.     bin5_t obj_no;
  508.     char buf3[3];
  509.     char display[33];
  510.     char *acom;
  511.     int i;
  512.     int names;
  513.  
  514.     /*
  515.     // Follow reference, if any.
  516.     */
  517.  
  518.     adr = follow_reference(adr);
  519.     SetWorkPtr(adr);
  520.  
  521.     /*
  522.     // Display header comment.
  523.     */
  524.  
  525.     acom = get_address_comment(adr);
  526.     if (*acom) {
  527.         pager(0);
  528.         printf("%05lX: ; *** %s ***\n", adr, acom);
  529.     }
  530. /*
  531.     pager(0);
  532.     printf("%05lX: ! *** Hash table for library %03lX (XLIB %ld) ***\n",
  533.         adr, lib_no, lib_no);
  534. */
  535.  
  536.     tmp = get_bin5();
  537.     pager(0);
  538.     if (tmp == prolog_binary_integer)
  539.         printf("%05lX: %05lX ! (Binary Integer)\n", adr, tmp);
  540.     else
  541.         printf("%05lX: %05lX ! ???\n", adr, tmp);
  542.  
  543.     adr = WorkPtr;
  544.     ht_size = get_bin5();
  545.     ht_end = adr + ht_size;
  546.  
  547.     /*
  548.     // Name hashed by length.
  549.     */
  550.  
  551.     pager(0);
  552.     printf("%05lX: %05lX ! %ld nibbles (next at %05lX)\n",
  553.         adr, ht_size, ht_size, ht_end );
  554.  
  555.     for (i = 1; i <= 16; i++) {
  556.  
  557.         adr = WorkPtr;
  558.         tmp = get_bin5();
  559.  
  560.         pager(0);
  561.         if (tmp == 0) {
  562.             printf("%05lX: %05lX !   %2d none\n",
  563.                 adr, tmp, i );
  564.         } else {
  565.             printf("%05lX: %05lX !   %2d at %05lX\n",
  566.                 adr, tmp, i, (adr + tmp) & 0xFFFFF);
  567.         }
  568.     }
  569.  
  570.     adr = WorkPtr;
  571.     nt_size = get_bin5();
  572.     nt_end = adr + nt_size;
  573.  
  574.     /*
  575.     // Names sorted first by length and the alphabetically.
  576.     */
  577.  
  578.     pager(0);
  579.     printf("%05lX: %05lX ! %ld nibbles (next at %05lX)\n",
  580.         adr, nt_size, nt_size, nt_end );
  581.  
  582.     names = 0;
  583.     adr = WorkPtr;
  584.  
  585.     while (adr < nt_end) {
  586.         names++;
  587.         get_ascic(display);
  588.         GetNNibbles(buf3,3);
  589.         strrev(buf3);
  590.         obj_no = str2adr(buf3,0);
  591.  
  592.         pager(0);
  593.         printf("%05lX: [...] !   %s (XLIB %ld %ld)\n",
  594.             adr, display, lib_no, obj_no );
  595.  
  596.         adr = WorkPtr;
  597.     }
  598.  
  599.     /*
  600.     // XLIB number to name offsets (backward pointing).
  601.     */
  602.  
  603.     i = 0;
  604.     adr = WorkPtr;
  605.  
  606.     while (adr < ht_end) {
  607.         tmp = get_bin5();
  608.  
  609.         pager(0);
  610.         printf("%05lX: %05lX !   name for XLIB %ld %d at %05lX\n",
  611.             adr, tmp, lib_no, i, (adr - tmp) & 0xFFFFF);
  612.  
  613.         i++;
  614.         adr = WorkPtr;
  615.     }
  616. }
  617.  
  618. /***********************************************************************
  619.     display_message_table
  620. ***********************************************************************/
  621.  
  622. void display_message_table(bin5_t adr, bin5_t lib_no)
  623. {
  624.     bin5_t tmp;
  625.  
  626.     /*
  627.     // Follow reference, if any.
  628.     */
  629.  
  630.     adr = follow_reference(adr);
  631.     SetWorkPtr(adr);
  632. /*
  633.     pager(0);
  634.     printf("%05lX: ! *** Message table for library %03lX (XLIB %ld) ***\n",
  635.         adr, lib_no, lib_no);
  636. */
  637.     tmp = get_bin5();
  638.     display_object(&adr, &tmp);
  639. }
  640.  
  641. /***********************************************************************
  642.     display_link_table
  643. ***********************************************************************/
  644.  
  645. void display_link_table(bin5_t adr, bin5_t lib_no)
  646. {
  647.     bin5_t lt_size;
  648.     bin5_t lt_end;
  649.     bin5_t tmp;
  650.     int i;
  651.     char *acom;
  652.  
  653.     /*
  654.     // Follow reference, if any.
  655.     */
  656.  
  657.     adr = follow_reference(adr);
  658.     SetWorkPtr(adr);
  659.  
  660.     /*
  661.     // Display header comment.
  662.     */
  663.  
  664.     acom = get_address_comment(adr);
  665.     if (*acom) {
  666.         pager(0);
  667.         printf("%05lX: ; *** %s ***\n", adr, acom);
  668.     }
  669. /*
  670.     pager(0);
  671.     printf("%05lX: ! *** Link table for library %03lX (XLIB %ld) ***\n",
  672.         adr, lib_no, lib_no);
  673. */
  674.     tmp = get_bin5();
  675.     pager(0);
  676.     if (tmp == prolog_binary_integer)
  677.         printf("%05lX: %05lX ! (Binary Integer)\n", adr, tmp);
  678.     else
  679.         printf("%05lX: %05lX ! ???\n", adr, tmp);
  680.  
  681.     adr = WorkPtr;
  682.     lt_size = get_bin5();
  683.     lt_end = adr + lt_size;
  684.  
  685.     pager(0);
  686.     printf("%05lX: %05lX ! %ld nibbles (next at %05lX)\n",
  687.         adr, lt_size, lt_size, lt_end );
  688.  
  689.     i = 0;
  690.     adr = WorkPtr;
  691.  
  692.     while (adr < lt_end) {
  693.  
  694.         tmp = get_bin5();
  695.  
  696.         pager(0);
  697.         printf("%05lX: %05lX !   XLIB %ld %d at %05lX\n",
  698.             adr, tmp, lib_no, i, (adr + tmp) & 0xFFFFF);
  699.  
  700.         i++;
  701.         adr = WorkPtr;
  702.     }
  703. }
  704.  
  705. /***********************************************************************
  706.     display_conf_code
  707. ***********************************************************************/
  708.  
  709. static void display_conf_code(bin5_t adr)
  710. {
  711.     bin5_t ta;
  712.  
  713.     /*
  714.     // Follow reference, if any.
  715.     */
  716.  
  717.     adr = follow_reference(adr);
  718.     SetWorkPtr(adr);
  719.  
  720.     ta = get_bin5();
  721.     display_object(&adr, &ta);
  722. }
  723.  
  724. /***********************************************************************
  725.     display_short_library
  726. ***********************************************************************/
  727.  
  728. void display_short_library(bin5_t adr)
  729. {
  730.     char buf2[6];
  731.     bin5_t tmp;
  732.     bin5_t lib_no;
  733.     bin5_t hash_table;
  734.     bin5_t message_table;
  735.     bin5_t link_table;
  736.     bin5_t conf_code;
  737.     char *acom;
  738.  
  739.     /*
  740.     // Follow reference, if any.
  741.     */
  742.  
  743.     adr = follow_reference(adr);
  744.     SetWorkPtr(adr);
  745.  
  746.     /*
  747.     // Display header comment.
  748.     */
  749.  
  750.     acom = get_address_comment(adr);
  751.     if (*acom) {
  752.         pager(0);
  753.         printf("%05lX: ; *** %s ***\n", adr, acom);
  754.     }
  755.  
  756.     /*
  757.     // Display the short library header.
  758.     */
  759.  
  760.     adr = WorkPtr;
  761.     GetNNibbles(buf2,3);
  762.     strrev(buf2);
  763.     lib_no = str2adr(buf2,0);
  764.  
  765.     pager(0);
  766.     printf("%05lX: %03lX   ! Library %03lX (XLIB %ld)\n",
  767.         adr, lib_no, lib_no, lib_no );
  768.  
  769.     adr = WorkPtr;
  770.     tmp = get_bin5();
  771.  
  772.     pager(0);
  773.     if (tmp == 0) {
  774.         hash_table = 0;
  775.         printf("%05lX: %05lX ! No hash table\n",
  776.             adr, tmp );
  777.     } else {
  778.         hash_table = (tmp + adr) & 0xFFFFF;
  779.         printf("%05lX: %05lX ! Hash table at %05lX\n",
  780.             adr, tmp, hash_table );
  781.     }
  782.  
  783.     adr = WorkPtr;
  784.     tmp = get_bin5();
  785.  
  786.     pager(0);
  787.     if (tmp == 0) {
  788.         message_table = 0;
  789.         printf("%05lX: %05lX ! No message table\n",
  790.             adr, tmp );
  791.     } else {
  792.         message_table = (tmp + adr) & 0xFFFFF;
  793.         printf("%05lX: %05lX ! Message table at %05lX\n",
  794.             adr, tmp, message_table );
  795.     }
  796.  
  797.     adr = WorkPtr;
  798.     tmp = get_bin5();
  799.  
  800.     pager(0);
  801.     if (tmp == 0) {
  802.         link_table = 0;
  803.         printf("%05lX: %05lX ! No link table\n",
  804.             adr, tmp );
  805.     } else {
  806.         link_table = (tmp + adr) & 0xFFFFF;
  807.         printf("%05lX: %05lX ! Link table at %05lX\n",
  808.             adr, tmp, link_table );
  809.     }
  810.  
  811.     adr = WorkPtr;
  812.     tmp = get_bin5();
  813.  
  814.     pager(0);
  815.     if (tmp == 0) {
  816.         conf_code = 0;
  817.         printf("%05lX: %05lX ! No configuration code\n",
  818.             adr, tmp );
  819.     } else {
  820.         conf_code = (tmp + adr) & 0xFFFFF;
  821.         printf("%05lX: %05lX ! Configuration code at %05lX\n",
  822.             adr, tmp, conf_code );
  823.     }
  824. }
  825.  
  826. /***********************************************************************
  827.     display_object
  828. ***********************************************************************/
  829.  
  830. static int display_object(bin5_t *origWP, bin5_t *ta)
  831. {
  832.     int asmMode = 0;
  833.     char *acom;
  834.  
  835.     /*
  836.     // Display header comment.
  837.     */
  838.  
  839.     acom = get_address_comment(*origWP);
  840.     if (*acom) {
  841.         pager(0);
  842.         printf("%05lX: ; *** %s ***\n", *origWP, acom);
  843.     }
  844.  
  845.     /*
  846.     // What kind of instruction or object is this?
  847.     */
  848.  
  849.     if (*ta == WorkPtr) {
  850.         /*
  851.         // Machine code entry point.  Thread points to the very
  852.         // next nibble.
  853.         */
  854.  
  855.         pager(0);
  856.         printf("%05lX: %05lX ! Machine Code at %05lX\n",
  857.             *origWP, *ta, *ta );
  858.  
  859.         asmMode = 1;
  860.  
  861.     } else if (*ta == prolog_system_binary) {
  862.         /*
  863.         // System Binary.
  864.         */
  865.  
  866.         char buf2[6];
  867.         char display[9];
  868.         bin5_t data;
  869.  
  870.         data = get_bin5();
  871.  
  872.         pager(0);
  873.         acom = get_address_comment(data);
  874.         if (*acom)
  875.             printf("%05lX: [...] ! <%lXh>\t; %s\n",
  876.                 *origWP, data, acom );
  877.         else
  878.             printf("%05lX: [...] ! <%lXh>\n", *origWP, data );
  879.  
  880.     } else if (*ta == prolog_real_number) {
  881.         /*
  882.         // Real Number.
  883.         */
  884.  
  885.         char buf2[17];
  886.         char display[20];
  887.  
  888.         GetNNibbles(buf2,16);
  889.         format_real_number(buf2,display);
  890.  
  891.         pager(0);
  892.         printf("%05lX: [...] ! %s\n", *origWP, display);
  893.  
  894.     } else if (*ta == prolog_long_real) {
  895.         /*
  896.         // Long Real.
  897.         */
  898.  
  899.         char buf2[22];
  900.         char display[25];
  901.  
  902.         GetNNibbles(buf2,21);
  903.         format_long_real(buf2,display);
  904.  
  905.         pager(0);
  906.         printf("%05lX: [...] ! %s (Long Real)\n", *origWP, display);
  907.  
  908.     } else if (*ta == prolog_complex_number) {
  909.         /*
  910.         // Complex Number.
  911.         */
  912.  
  913.         char buf2[17];
  914.         char re_display[20];
  915.         char im_display[20];
  916.  
  917.         GetNNibbles(buf2,16);
  918.         format_real_number(buf2,re_display);
  919.  
  920.         GetNNibbles(buf2,16);
  921.         format_real_number(buf2,im_display);
  922.  
  923.         pager(0);
  924.         printf("%05lX: [...] ! (%s,%s)\n",
  925.             *origWP, re_display, im_display);
  926.  
  927.     } else if (*ta == prolog_long_complex) {
  928.         /*
  929.         // Long Complex.
  930.         */
  931.  
  932.         char buf2[22];
  933.         char re_display[25];
  934.         char im_display[25];
  935.  
  936.         GetNNibbles(buf2,21);
  937.         format_long_real(buf2,re_display);
  938.  
  939.         GetNNibbles(buf2,21);
  940.         format_long_real(buf2,im_display);
  941.  
  942.         pager(0);
  943.         printf("%05lX: [...] ! (%s,%s) (Long Complex)\n",
  944.             *origWP, re_display, im_display );
  945.  
  946.     } else if (*ta == prolog_character) {
  947.         /*
  948.         // Character.
  949.         */
  950.  
  951.         char buf2[3];
  952.         char display[9];
  953.  
  954.         GetNNibbles(buf2,2);
  955.         format_character(buf2,display);
  956.         pager(0);
  957.         printf("%05lX: [...] ! %s (Character)\n",
  958.             *origWP, display);
  959.  
  960.     } else if (*ta == prolog_array) {
  961.         /*
  962.         // Array.
  963.         */
  964.  
  965.         char buf2[6];
  966.         char buf3[33];
  967.         bin5_t size;
  968.         bin5_t item_prolog;
  969.         bin5_t num_dims;
  970.         bin5_t dim_n;
  971.         bin5_t c_dim;
  972.         bin5_t total_elements;
  973.         bin5_t c_element;
  974.  
  975.         pager(0);
  976.         printf("%05lX: %05lX ! Array\n", *origWP, *ta );
  977.  
  978.         *origWP = WorkPtr;
  979.         size = get_bin5();
  980.         pager(0);
  981.         printf("%05lX: %05lX ! %ld nibbles\n",
  982.             *origWP, size, size);
  983.  
  984.         *origWP = WorkPtr;
  985.         item_prolog = get_bin5();
  986.         pager(0);
  987.         printf("%05lX: %05lX ! ...of %s\n",
  988.             *origWP, item_prolog,
  989.             get_prolog_description(item_prolog,buf3) );
  990.  
  991.         *origWP = WorkPtr;
  992.         num_dims = get_bin5();
  993.         pager(0);
  994.         printf("%05lX: %05lX ! %ld dimensional\n",
  995.             *origWP, num_dims, num_dims );
  996.  
  997.         total_elements = 1;
  998.  
  999.         for (dim_n = 1; dim_n <= num_dims; dim_n++) {
  1000.             *origWP = WorkPtr;
  1001.             c_dim = get_bin5();
  1002.             total_elements *= c_dim;
  1003.             pager(0);
  1004.             printf("%05lX: %05lX ! Dim-%ld = %ld\n",
  1005.                 *origWP, c_dim, dim_n, c_dim );
  1006.         }
  1007.  
  1008.         pager(0);
  1009.         printf(" . . . . . . ! %ld total elements\n",
  1010.             total_elements );
  1011.  
  1012.         for (c_element = 1; c_element <= total_elements; c_element++) {
  1013.             *origWP = WorkPtr;
  1014.             asmMode = display_object(origWP, &item_prolog);
  1015.         }
  1016.  
  1017.     } else if (*ta == prolog_string) {
  1018.         /*
  1019.         // String.
  1020.         */
  1021.  
  1022.         char buf3[65];
  1023.         char display[33];
  1024.         bin5_t size;
  1025.         int j, ch, dlen;
  1026.  
  1027.         size = (get_bin5()-5)/2;
  1028.  
  1029.         if (size <= 32) {
  1030.             /*
  1031.             // Can be printed on one line.
  1032.             */
  1033.  
  1034.             GetNNibbles(buf3,2*size);
  1035.             hex_to_text(buf3, display);
  1036.  
  1037.             pager(0);
  1038.             printf("%05lX: [...] ! \"%s\"\n",
  1039.                 *origWP, display);
  1040.  
  1041.         } else {
  1042.             /*
  1043.             // Needs two or more lines to print.
  1044.             */
  1045.  
  1046.             GetNNibbles(buf3,64);
  1047.             hex_to_text(buf3, display);
  1048.             pager(0);
  1049.             printf("%05lX: [...] ! \"%s\n",
  1050.                 *origWP, display);
  1051.             size -= 32;
  1052.  
  1053.             while (size > 32) {
  1054.                 *origWP = WorkPtr;
  1055.                 GetNNibbles(buf3,64);
  1056.                 hex_to_text(buf3, display);
  1057.                 pager(0);
  1058.                 printf("%05lX: [...] ! %s\n",
  1059.                     *origWP, display);
  1060.                 size -= 32;
  1061.             }
  1062.  
  1063.              *origWP = WorkPtr;
  1064.             GetNNibbles(buf3,2*size);
  1065.             hex_to_text(buf3, display);
  1066.             pager(0);
  1067.             printf("%05lX: [...] ! %s\"\n",
  1068.                 *origWP,display);
  1069.         }
  1070.  
  1071.     } else if (*ta == prolog_binary_integer) {
  1072.         /*
  1073.         // Binary Integer.
  1074.         */
  1075.  
  1076.         char buf3[33];
  1077.         char display[17];
  1078.         bin5_t size;
  1079.  
  1080.         size = get_bin5() - 5;
  1081.  
  1082.         if (size <= 32) {
  1083.             /*
  1084.             // Can be printed on one line.
  1085.             */
  1086.  
  1087.             GetNNibbles(buf3,size);
  1088.             strrev(buf3);
  1089.             pager(0);
  1090.             printf("%05lX: [...] ! # %sh\n", *origWP, buf3);
  1091.  
  1092.         } else {
  1093.             /*
  1094.             // Needs more than one line to print.
  1095.             */
  1096.  
  1097.             pager(0);
  1098.             printf("%05lX: [...] ! Binary Integer (%ld nibbles)\n",
  1099.                 *origWP, size );
  1100.  
  1101.             while (size > 32) {
  1102.                 *origWP = WorkPtr;
  1103.                 GetNNibbles(buf3,32);
  1104.                 hex_to_text(buf3,display);
  1105.                 strrev(buf3);
  1106.                 pager(0);
  1107.                 printf(" %s %s %05lX\n",
  1108.                     buf3, display, *origWP );
  1109.                 size -= 32;
  1110.             }
  1111.  
  1112.             *origWP = WorkPtr;
  1113.             GetNNibbles(buf3,size);
  1114.             hex_to_text(buf3,display);
  1115.             strrev(buf3);
  1116.             pager(0);
  1117.             printf(" %32s %16s %05lX\n",
  1118.                 buf3, display, *origWP );
  1119.         }
  1120.  
  1121.     } else if (*ta == prolog_list) {
  1122.         /*
  1123.         // List.
  1124.         */
  1125.  
  1126.         pager(0);
  1127.         printf("%05lX: %05lX ! List\n", *origWP, *ta);
  1128.         pager(0);
  1129.         printf(" . . . . . . ! {\n");
  1130.  
  1131.         *origWP = WorkPtr;
  1132.         *ta = get_bin5();
  1133.  
  1134.         while (*ta != end_marker) {
  1135.             asmMode = display_object(origWP,ta);
  1136.             *origWP = WorkPtr;
  1137.             *ta = get_bin5();
  1138.         }
  1139.  
  1140.         pager(0);
  1141.         printf("%05lX: %05lX ! End Marker\n", *origWP, *ta);
  1142.         pager(0);
  1143.         printf(" . . . . . . ! }\n");
  1144.  
  1145.     } else if (*ta == prolog_directory) {
  1146.         /*
  1147.         // Directory.
  1148.         */
  1149.  
  1150.         char buf2[6];
  1151.         char display[33];
  1152.         bin5_t attach;
  1153.         bin5_t offset;
  1154.         bin5_t tmp2;
  1155.         bin5_t end_of_dir;
  1156.         unsigned long idx = 0;
  1157.  
  1158.         pager(0);
  1159.         printf("%05lX: %05lX ! Directory\n", *origWP, *ta);
  1160.  
  1161.         *origWP = WorkPtr;
  1162.         GetNNibbles(buf2,3);
  1163.         strrev(buf2);
  1164.         attach = str2adr(buf2,0);
  1165.         pager(0);
  1166.         if (attach == 0x7FF)
  1167.             printf("%05lX: %03lX   ! attachments: none\n",
  1168.                 *origWP, attach);
  1169.         else
  1170.             printf("%05lX: %03lX   ! attachments: %ld\n",
  1171.                 *origWP, attach, attach);
  1172.  
  1173.         idx++;
  1174.         *origWP = WorkPtr;
  1175.         offset = get_bin5();
  1176.         tmp2 = (*origWP + offset) & 0xFFFFF;
  1177.  
  1178.         end_of_dir = WorkPtr;
  1179.  
  1180.         while (offset != 0) {
  1181.  
  1182.             pager(0);
  1183.             printf("%05lX: %05lX ! object %ld at %05lX\n",
  1184.                 *origWP, offset, idx, tmp2);
  1185.  
  1186.             SetWorkPtr(tmp2);
  1187.  
  1188.             *origWP = WorkPtr;
  1189.             get_ascix(display);
  1190.             pager(0);
  1191.             printf("%05lX: [...] ! *** %s ***\n",
  1192.                 *origWP, display );
  1193.  
  1194.             *origWP = WorkPtr;
  1195.             *ta = get_bin5();
  1196.             asmMode = display_object(origWP,ta);
  1197.  
  1198.             if (idx == 1) end_of_dir = WorkPtr;
  1199.  
  1200.             tmp2-= 5;
  1201.             SetWorkPtr(tmp2);
  1202.  
  1203.             idx++;
  1204.             *origWP = WorkPtr;
  1205.             offset = get_bin5();
  1206.             tmp2 = (*origWP - offset) & 0xFFFFF;
  1207.         }
  1208.  
  1209.         pager(0);
  1210.         printf("%05lX: %05lX ! End of Directory Marker\n",
  1211.             *origWP, offset );
  1212.  
  1213.         /*
  1214.         // Restore work pointer to the physical end of the
  1215.         // directory; as if we had scanned the directory in
  1216.         // memory address order.
  1217.         */
  1218.  
  1219.         SetWorkPtr(end_of_dir);
  1220.         *origWP = WorkPtr;
  1221.  
  1222.     } else if (*ta == prolog_algebraic) {
  1223.         /*
  1224.         // Algebraic.
  1225.         */
  1226.  
  1227.         pager(0);
  1228.         printf("%05lX: %05lX ! Algebraic\n", *origWP, *ta);
  1229.  
  1230.         *origWP = WorkPtr;
  1231.         *ta = get_bin5();
  1232.  
  1233.         while (*ta != end_marker) {
  1234.             asmMode = display_object(origWP,ta);
  1235.             *origWP = WorkPtr;
  1236.             *ta = get_bin5();
  1237.         }
  1238.  
  1239.         pager(0);
  1240.         printf("%05lX: %05lX ! End Marker\n", *origWP, *ta);
  1241.  
  1242.     } else if (*ta == prolog_unit) {
  1243.         /*
  1244.         // Unit.
  1245.         */
  1246.  
  1247.         pager(0);
  1248.         printf("%05lX: %05lX ! Unit\n", *origWP, *ta);
  1249.  
  1250.         *origWP = WorkPtr;
  1251.         *ta = get_bin5();
  1252.  
  1253.         while (*ta != end_marker) {
  1254.             asmMode = display_object(origWP,ta);
  1255.             *origWP = WorkPtr;
  1256.             *ta = get_bin5();
  1257.         }
  1258.  
  1259.         pager(0);
  1260.         printf("%05lX: %05lX ! End Marker\n", *origWP, *ta);
  1261.  
  1262.     } else if (*ta == prolog_tagged) {
  1263.         /*
  1264.         // Tagged.
  1265.         */
  1266.  
  1267.         char display[33];
  1268.  
  1269.         pager(0);
  1270.         printf("%05lX: %05lX ! Tagged\n", *origWP, *ta);
  1271.  
  1272.         *origWP = WorkPtr;
  1273.         get_ascic(display);
  1274.         pager(0);
  1275.         printf("%05lX: [...] ! :%s:\n", *origWP, display );
  1276.  
  1277.         *origWP = WorkPtr;
  1278.         *ta = get_bin5();
  1279.         asmMode = display_object(origWP,ta);
  1280.  
  1281.         pager(0);
  1282.         printf(" . . . . . . ! End Tagged\n", *origWP, *ta);
  1283.  
  1284.     } else if (*ta == prolog_graphic) {
  1285.         /*
  1286.         // Graphic.
  1287.         */
  1288.  
  1289.         char buf2[65];
  1290.         bin5_t columns;
  1291.         bin5_t rows;
  1292.         bin5_t size;
  1293.         int row;
  1294.         int nibs_per_row;
  1295.         div_t x;
  1296.  
  1297.         pager(0);
  1298.         printf("%05lX: %05lX ! Graphic\n", *origWP, *ta);
  1299.  
  1300.         *origWP = WorkPtr;
  1301.         size = get_bin5();
  1302.         pager(0);
  1303.         printf("%05lX: %05lX ! %ld nibbles (next at %05lX)\n",
  1304.             *origWP, size, size, *origWP + size);
  1305.  
  1306.         *origWP = WorkPtr;
  1307.         rows = get_bin5();
  1308.         pager(0);
  1309.         printf("%05lX: %05lX ! %ld rows\n",
  1310.             *origWP, rows, rows);
  1311.  
  1312.         *origWP = WorkPtr;
  1313.         columns = get_bin5();
  1314.         pager(0);
  1315.         printf("%05lX: %05lX ! %ld columns\n",
  1316.             *origWP, columns, columns);
  1317.  
  1318.         size -= 15;
  1319.  
  1320.         x = div(columns,8);
  1321.         nibs_per_row = 2*x.quot;
  1322.         if (x.rem != 0) nibs_per_row += 2;
  1323.  
  1324.         for (row = 0; row < rows; row++) {
  1325.             *origWP = WorkPtr;
  1326.             GetNNibbles(buf2,nibs_per_row);
  1327.             pager(0);
  1328.             printf("%05lX: [...] ! %s\n", *origWP, buf2);
  1329.         }
  1330.  
  1331.         pager(0);
  1332.         printf(" . . . . . . ! End of Graphic\n");
  1333.  
  1334.     } else if (*ta == prolog_library) {
  1335.         /*
  1336.         // Library.
  1337.         */
  1338.  
  1339.         char buf2[6];
  1340.         char display[33];
  1341.         bin5_t size;
  1342.         bin5_t end_of_library;
  1343.         bin5_t tmp;
  1344.         bin5_t lib_no;
  1345.         bin5_t hash_table;
  1346.         bin5_t message_table;
  1347.         bin5_t link_table;
  1348.         bin5_t conf_code;
  1349.  
  1350.         pager(0);
  1351.         printf("%05lX: %05lX ! Library\n", *origWP, *ta );
  1352.  
  1353.         *origWP = WorkPtr;
  1354.         size = get_bin5();
  1355.         end_of_library = *origWP + size;
  1356.  
  1357.         pager(0);
  1358.         printf("%05lX: %05lX ! %ld nibbles (next RPL at %05lX)\n",
  1359.             *origWP, size, size, end_of_library );
  1360.  
  1361.         *origWP = WorkPtr;
  1362.         get_ascix(display);
  1363.  
  1364.         pager(0);
  1365.         printf("%05lX: [...] ! Library name: \"%s\"\n",
  1366.             *origWP, display );
  1367.  
  1368.         *origWP = WorkPtr;
  1369.         GetNNibbles(buf2,3);
  1370.         strrev(buf2);
  1371.         lib_no = str2adr(buf2,0);
  1372.  
  1373.         pager(0);
  1374.         printf("%05lX: %03lX   ! Library %03lX (XLIB %ld)\n",
  1375.             *origWP, lib_no, lib_no, lib_no );
  1376.  
  1377.         *origWP = WorkPtr;
  1378.         tmp = get_bin5();
  1379.  
  1380.         pager(0);
  1381.         if (tmp == 0) {
  1382.             hash_table = 0;
  1383.             printf("%05lX: %05lX ! No hash table\n",
  1384.                 *origWP, tmp );
  1385.         } else {
  1386.             hash_table = (tmp + *origWP) & 0xFFFFF;
  1387.             printf("%05lX: %05lX ! Hash table at %05lX\n",
  1388.                 *origWP, tmp, hash_table );
  1389.         }
  1390.  
  1391.         *origWP = WorkPtr;
  1392.         tmp = get_bin5();
  1393.  
  1394.         pager(0);
  1395.         if (tmp == 0) {
  1396.             message_table = 0;
  1397.             printf("%05lX: %05lX ! No message table\n",
  1398.                 *origWP, tmp );
  1399.         } else {
  1400.             message_table = (tmp + *origWP) & 0xFFFFF;
  1401.             printf("%05lX: %05lX ! Message table at %05lX\n",
  1402.                 *origWP, tmp, message_table );
  1403.         }
  1404.  
  1405.         *origWP = WorkPtr;
  1406.         tmp = get_bin5();
  1407.  
  1408.         pager(0);
  1409.         if (tmp == 0) {
  1410.             link_table = 0;
  1411.             printf("%05lX: %05lX ! No link table\n",
  1412.                 *origWP, tmp );
  1413.         } else {
  1414.             link_table = (tmp + *origWP) & 0xFFFFF;
  1415.             printf("%05lX: %05lX ! Link table at %05lX\n",
  1416.                 *origWP, tmp, link_table );
  1417.         }
  1418.  
  1419.         *origWP = WorkPtr;
  1420.         tmp = get_bin5();
  1421.  
  1422.         pager(0);
  1423.         if (tmp == 0) {
  1424.             conf_code = 0;
  1425.             printf("%05lX: %05lX ! No configuration code\n",
  1426.                 *origWP, tmp );
  1427.         } else {
  1428.             conf_code = (tmp + *origWP) & 0xFFFFF;
  1429.             printf("%05lX: %05lX ! Configuration code at %05lX\n",
  1430.                 *origWP, tmp, conf_code );
  1431.         }
  1432. /*
  1433.         if (hash_table != 0)
  1434.             display_hash_table(hash_table, lib_no);
  1435.  
  1436.         if (message_table != 0)
  1437.             display_message_table(message_table, lib_no);
  1438.  
  1439.         if (link_table != 0)
  1440.             display_link_table(link_table, lib_no);
  1441.  
  1442.         if (conf_code != 0)
  1443.             display_conf_code(conf_code);
  1444. */
  1445.     } else if (*ta == prolog_backup) {
  1446.         /*
  1447.         // Backup.
  1448.         */
  1449.  
  1450.         bin5_t size;
  1451.         bin5_t end_of_backup;
  1452.         char display[33];
  1453.  
  1454.         pager(0);
  1455.         printf("%05lX: %05lX ! Backup\n", *origWP, *ta);
  1456.  
  1457.         *origWP = WorkPtr;
  1458.         size = get_bin5();
  1459.         end_of_backup = *origWP + size;
  1460.  
  1461.         pager(0);
  1462.         printf("%05lX: %05lX ! %ld nibbles (next RPL at %05lX)\n",
  1463.             *origWP, size, size, end_of_backup );
  1464.  
  1465.         *origWP = WorkPtr;
  1466.         get_ascix(display);
  1467.         pager(0);
  1468.         printf("%05lX: [...] ! name: %s\n",
  1469.             *origWP, display );
  1470.  
  1471.         *origWP = WorkPtr;
  1472.  
  1473.         while (*origWP < end_of_backup) {
  1474.             *ta = get_bin5();
  1475.             asmMode = display_object(origWP,ta);
  1476.             *origWP = WorkPtr;
  1477.         }
  1478.  
  1479.         pager(0);
  1480.         printf(" . . . . . . ! End of Backup\n");
  1481.  
  1482.     } else if (*ta == prolog_library_data) {
  1483.         /*
  1484.         // Library Data.
  1485.         */
  1486.  
  1487.         bin5_t size;
  1488.         bin5_t end_of_libdat;
  1489.         bin5_t ident;
  1490.         bin5_t libno;
  1491.         bin5_t objno;
  1492.         int stop;
  1493.         int save_follow;
  1494.  
  1495.         pager(0);
  1496.         printf("%05lX: %05lX ! Library Data\n", *origWP, *ta );
  1497.  
  1498.         *origWP = WorkPtr;
  1499.         size = get_bin5();
  1500.         end_of_libdat = *origWP + size;
  1501.  
  1502.         pager(0);
  1503.         printf("%05lX: %05lX ! %ld nibbles (next RPL at %05lX)\n",
  1504.             *origWP, size, size, end_of_libdat );
  1505.  
  1506.         *origWP = WorkPtr;
  1507.         ident = get_bin5();
  1508.  
  1509.         libno = ident & 0xFFF;
  1510.         objno = 12>>ident;
  1511.  
  1512.         pager(0);
  1513.         printf("%05lX: %05lX ! ident: %03lX/%02lX (%ld/%ld)\n",
  1514.             *origWP, ident, libno, objno, libno, objno );
  1515.  
  1516.         while (WorkPtr < end_of_libdat) {
  1517.             *origWP = WorkPtr;
  1518.             *ta = get_bin5();
  1519.             asmMode = display_object(origWP,ta);
  1520.         }
  1521.  
  1522.         pager(0);
  1523.         printf(" . . . . . . ! End of Library Data\n");
  1524.  
  1525.     } else if (*ta == prolog_program) {
  1526.         /*
  1527.         // Program.
  1528.         */
  1529.  
  1530.         pager(0);
  1531.         printf("%05lX: %05lX ! Program\n", *origWP, *ta);
  1532.  
  1533.         *origWP = WorkPtr;
  1534.         *ta = get_bin5();
  1535.  
  1536.         while (*ta != end_marker) {
  1537.             asmMode = display_object(origWP,ta);
  1538.             *origWP = WorkPtr;
  1539.             *ta = get_bin5();
  1540.         }
  1541.  
  1542.         pager(0);
  1543.         printf("%05lX: %05lX ! End Marker\n", *origWP, *ta);
  1544.  
  1545.     } else if (*ta == prolog_code) {
  1546.         /*
  1547.         // Code.
  1548.         */
  1549.  
  1550.         bin5_t size;
  1551.         bin5_t end_of_code;
  1552.         int stop;
  1553.         int save_follow;
  1554.  
  1555.         pager(0);
  1556.         printf("%05lX: %05lX ! Code\n", *origWP, *ta );
  1557.  
  1558.         *origWP = WorkPtr;
  1559.         size = get_bin5();
  1560.         end_of_code = *origWP + size;
  1561.  
  1562.         pager(0);
  1563.         printf("%05lX: %05lX ! %ld nibbles (next RPL at %05lX)\n",
  1564.             *origWP, size, size, end_of_code );
  1565.  
  1566.         save_follow = modes.follow;
  1567.         modes.follow = 0;
  1568.  
  1569.         while (WorkPtr < end_of_code)
  1570.             unassem1instr(&stop);
  1571.  
  1572.         pager(0);
  1573.         printf(" . . . . . . ! End of Code\n");
  1574.  
  1575.         modes.follow = save_follow;
  1576.  
  1577.     } else if (*ta == prolog_global_name) {
  1578.         /*
  1579.         // Global Name.
  1580.         */
  1581.  
  1582.         char display[33];
  1583.  
  1584.         get_ascic(display);
  1585.  
  1586.         pager(0);
  1587.         printf("%05lX: [...] ! '%s' (Global Name)\n",
  1588.             *origWP, display );
  1589.  
  1590.     } else if (*ta == prolog_local_name) {
  1591.         /*
  1592.         // Local Name.
  1593.         */
  1594.  
  1595.         char display[33];
  1596.  
  1597.         get_ascic(display);
  1598.  
  1599.         pager(0);
  1600.         printf("%05lX: [...] ! '%s' (Local Name)\n",
  1601.             *origWP, display );
  1602.  
  1603.     } else if (*ta == prolog_xlib_name) {
  1604.         /*
  1605.         // XLIB Name.
  1606.         */
  1607.  
  1608.         char buf2[4];
  1609.         bin5_t lib;
  1610.         bin5_t fn;
  1611.  
  1612.         GetNNibbles(buf2,3);
  1613.         strrev(buf2);
  1614.         lib = str2adr(buf2,0);
  1615.  
  1616.         GetNNibbles(buf2,3);
  1617.         strrev(buf2);
  1618.         fn = str2adr(buf2,0);
  1619.  
  1620.         pager(0);
  1621.         printf("%05lX: [...] ! XLIB %ld %ld\n",
  1622.             *origWP, lib, fn );
  1623.  
  1624.     } else {
  1625.         /*
  1626.         // Plain RPL.
  1627.         */
  1628.  
  1629.         pager(0);
  1630.         acom = get_address_comment(*ta);
  1631.         if (*acom)
  1632.             printf("%05lX: %05lX ; %s\n", *origWP, *ta, acom);
  1633.         else
  1634.             printf("%05lX: %05lX\n", *origWP, *ta);
  1635.  
  1636.     }
  1637.  
  1638.     return asmMode;
  1639. }
  1640.  
  1641. /***********************************************************************
  1642.     display_current_object
  1643. ***********************************************************************/
  1644.  
  1645. int display_current_object(int *stop)
  1646. {
  1647.     bin5_t origWP = WorkPtr;
  1648.     bin5_t ta;
  1649.     int asmMode;
  1650.  
  1651.     /*
  1652.     // Get the next threaded instruction or object, display it and
  1653.     // check for stop condition,
  1654.     */
  1655.  
  1656.     ta = get_bin5();
  1657.     asmMode = display_object(&origWP, &ta);
  1658.     *stop = (ta == end_marker);
  1659.  
  1660.     return asmMode;
  1661. }
  1662.